package com.example.demo1122.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo1122.DTO.StudentDTO;
import com.example.demo1122.domain.LoginStudent;
import com.example.demo1122.domain.ResponseResult;
import com.example.demo1122.entity.Class;
import com.example.demo1122.entity.Student;
import com.example.demo1122.mapper.ClassMapper;
import com.example.demo1122.mapper.ClassstuMapper;
import com.example.demo1122.mapper.StudentMapper;
import com.example.demo1122.service.IClassstuService;
import com.example.demo1122.service.IStudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;

import java.util.List;

import static org.apache.logging.log4j.util.Strings.isEmpty;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author baomidou
 * @since 2023-12-07
 */
@Service
public class StudentServiceImpl extends ServiceImpl<StudentMapper, Student> implements IStudentService {

    @Resource
    private ClassstuMapper classStuMapper;
    @Resource
    private ClassMapper classMapper;
    @Resource
    private PasswordEncoder passwordEncoder;
    @Resource
    private StudentMapper studentMapper;
    @Resource
    private IClassstuService classStuService;

//新增单个学生

    @Override
    public ResponseResult saveStudent(Student student) {
        if(isEmpty(student.getStudentID())){
            return new ResponseResult(303, "学号不能为空");
        }
        else {
            if (studentMapper.isStudentIDExists(student)) {
                // 学生ID已存在，执行绑定studentID与classID操作
//                studentMapper.update(student);
                return new ResponseResult(105, "插入失败,学号已存在");
            } else {
                // 学生ID不存在，执行插入操作
                studentMapper.insert(student);
                return new ResponseResult(300, "插入成功");
            }
        }
    }
//更新单个学生信息
    @Override
    public ResponseResult updateStudent(StudentDTO student) {
        Student tempstu=new Student();
        tempstu.setPassword("123456");
        tempstu.setName(student.getName());
        tempstu.setStudentID(student.getStudentID());
            if (studentMapper.isStudentIDExists(tempstu)) {

                // 学生ID已存在，执行更新操作
                studentMapper.updatedto(student);
                return new ResponseResult(305, "修改成功");
            } else {
                // 学生ID不存在，更新失败
//                studentMapper.insert(student);
                return new ResponseResult(100, "修改失败,学生不存在");
            }

    }
    //修改密码
    @Override
    public ResponseResult updateStudentpassword(Student student) {
        Student tempstu=new Student();
        tempstu.setPassword("123456");
        tempstu.setName("tempname");
        tempstu.setStudentID(student.getStudentID());
        if (studentMapper.isStudentIDExists(tempstu)) {
            tempstu=studentMapper.selectbyID(tempstu);
            if(isEmpty(student.getName())){
                student.setName(tempstu.getName());
            }
            // 学生ID已存在，执行更新操作
            studentMapper.update(student);
            return new ResponseResult(305, "修改成功");
        } else {
            // 学生ID不存在，更新失败
//                studentMapper.insert(student);
            return new ResponseResult(100, "修改失败,学生不存在");
        }

    }


    @Override
    public ResponseResult saveOrUpdateStudent(Student student, Integer classID) {
        Student existingStudent = studentMapper.selectById(student.getStudentID());
        if (studentMapper.isStudentIDExists(student)) {//学生已经存在,如果姓名与原ID不符，返回提示
            if(!getById(student.getStudentID()).getName().equals(student.getName())){
                return new ResponseResult(208,student.getName()+"的studentID已被占用");
            }
            //studentMapper.updateById(student);
        } else {//学生不存在,新增
            if(isEmpty(student.getPassword())){
                student.setPassword(passwordEncoder.encode("123456"));
            }
            //else student.setPassword(passwordEncoder.encode(student.getPassword()));
            studentMapper.insert(student);
        }
        if(classID==0){
            return new ResponseResult(2041, "成功导入学生");
        }
        return classStuService.addStudentToClass(student.getStudentID(), classID);
    }
    @Override
    public ResponseResult saveStudentList(List<Student> studentList, Integer classID) {
        List<String> occupiedNames = new ArrayList<>(); // 用于存储已被占用的学生姓名

        for (Student student : studentList) {

            // 尝试保存或更新学生信息
            ResponseResult result = saveOrUpdateStudent(student, classID);
            // 检查返回状态码，如果是208（即学生ID已被占用），则收集学生姓名
            if (result.getCode() == 208) {
                occupiedNames.add(student.getName());
            }
        }

        // 检查是否有占用的学生姓名
        if (!occupiedNames.isEmpty()) {
            // 返回包含所有占用姓名的消息
            return new ResponseResult(208, "以下学生的ID已被占用: " + String.join(", ", occupiedNames));
        } else {
            // 如果没有占用的学生姓名，表示批量插入/更新操作成功完成
            return new ResponseResult(200, "批量导入成功");
        }
    }

    @Override
    public void findAll() {
        studentMapper.findAll();

    }

//    @Override
//    public Page<Student> findPage(Page<Student> page, String studentID, String name) {
//        return studentMapper.findPage(page, studentID, name);
//    }
    @Override
    public Page<StudentDTO> findPage(int pageNum, int pageSize, String studentID, String name) {
        // 使用MyBatis Plus的分页查询
         Page<Student> page = studentMapper.findPage(new Page<>(pageNum, pageSize), studentID, name);
        // 转换为StudentDTO列表
          List<StudentDTO> dtos = convertToDTOList(page.getRecords());

    // 创建一个新的Page对象，其中包含DTOs和原始分页信息
    Page<StudentDTO> dtoPage = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
    dtoPage.setRecords(dtos);

    // 将分页信息和转换后的数据封装到ResponseResult中
    return dtoPage;
}

    // 在StudentService.java
    public List<Student> findStudentsByClassId(Integer classID) {
        // 调用ClassStuMapper的方法来获取所有的studentID
        List<String> studentIds = classStuMapper.selectStudentIdsByClassId(classID);
        if (studentIds.isEmpty()) {
            // 返回空列表或适当的错误响应
        } else {
            // 执行查询
        }

        // 从student表中获取所有的学生信息
        return studentMapper.selectBatchIds(studentIds);
    }




    public ResponseResult findallStudentsByClassId(Integer classID) {
        // 首先检查classID是否存在

        if (!classIdExists(classID)) {//如果课堂学生表中没有这个课堂，可能是没有这个课堂，也可能是这个课堂没有添加过学生
            Class classtemp=classMapper.selectById(classID);
            if (classtemp==null) {
                // classID不存在，返回相应提示
                return new ResponseResult<>(HttpStatus.NOT_FOUND.value(), "该classID不存在", Collections.emptyList());
            }
            // classID不存在，返回相应提示
            return new ResponseResult<>(2135, "该classID下没有学生", Collections.emptyList());
        } else {
            // 调用ClassStuMapper的方法来获取所有的studentID
            List<String> studentIds = classStuMapper.selectStudentIdsByClassId(classID);
            List<Student> students=studentMapper.selectBatchIds(studentIds);
            if (students.isEmpty()) {
                // 学生列表为空，返回空列表而不是null
                return new ResponseResult<>(2135, "该classID下没有学生", Collections.emptyList());
            } else {
                // 存在学生，返回学生列表
                List<StudentDTO> studentdtos=convertToDTOList(students);
                return new ResponseResult<>(HttpStatus.OK.value(), "查询成功", studentdtos);
            }
        }
    }

    private List<StudentDTO> convertToDTOList(List<Student> students) {
        // 编写转换逻辑，将 Student 转换为 StudentDTO
        List<StudentDTO> studentDTOs = new ArrayList<>();

        for (Student student : students) {
            StudentDTO studentDTO = new StudentDTO();
            studentDTO.setStudentID(student.getStudentID());

            studentDTO.setName(student.getName());

            // 如果有其他需要转换的字段，可以继续添加

            studentDTOs.add(studentDTO);
        }

        return studentDTOs;
    }

    // 检查classID是否存在的方法
    private boolean classIdExists(Integer classID) {
        // 假设你有一个方法来检查classID是否存在于classstu表中
        // 返回true如果存在，false如果不存在

        return classStuService.existsClassId(classID);
    }

   //分页+模糊查询，在某个课堂序号下
    public Page<StudentDTO> findPageByClassId(Integer pageNum, Integer pageSize, Integer classID, String studentID, String name) {
        // 获取属于特定classID的studentID列表
        List<String> studentIds = classStuMapper.selectStudentIdsByClassId(classID);
        if (studentIds.isEmpty()) {
            // 如果没有学生，返回空的Page对象
            return new Page<StudentDTO>();
        }
        // 使用MyBatis Plus的分页查询，基于studentID列表
        Page<Student> page = studentMapper.findPageByStudentIds(new Page<>(pageNum, pageSize), studentIds, studentID, name);
        // 转换为StudentDTO列表
        List<StudentDTO> dtos = convertToDTOList(page.getRecords());
        // 创建一个新的Page对象，其中包含DTOs和原始分页信息
        Page<StudentDTO> dtoPage = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        dtoPage.setRecords(dtos);
        return dtoPage;
    }

    //根据学生ID查看课堂
    public ResponseResult findclassByStudentId(String studentID) {
        // 首先检查studentID是否存在
        if (getById(studentID)==null) {
            // ID不存在，返回相应提示
            return new ResponseResult<>(HttpStatus.NOT_FOUND.value(), "该studentID不存在", Collections.emptyList());
        } else {
            // 调用ClassStuMapper的方法来获取所有的classID
            List<String> classIds = classStuMapper.selectClassIdsByStudentID(studentID);
            List<Class> classes=classMapper.selectBatchIds(classIds);
            if (classes.isEmpty()) {
                // 列表为空，返回空列表而不是null
                return new ResponseResult<>(HttpStatus.OK.value(), "该classID下没有学生", Collections.emptyList());
            } else {
                // 存在，返回学生列表
                return new ResponseResult<>(HttpStatus.OK.value(), "查询成功", classes);
            }
        }
    }

    @Override
    public ResponseResult getClassInfo(String studentID) {
        List<Class> classList = classMapper.getClassByStudentID(studentID);
        return new ResponseResult(1,"success", classList);

    }

    @Override
    public ResponseResult getProfile(String studentID) {
        try {
            Student student = studentMapper.getProfileByID(studentID);
            return new ResponseResult(1,"success", student);
        } catch (Exception e) {
            return new ResponseResult(0,"error",e);
        }
    }
}
